package com.jit.BluetoothKey.bluetooth;

import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.util.Log;

import com.orhanobut.logger.Logger;

import java.util.ArrayList;
import java.util.List;


/**
 * Created by Administrator on 2018/2/2.
 */

public class MyBluetoothGattcallback extends BluetoothGattCallback {

    String TAG = "MyBluetoothGattcallback";
    private BluetoothGatt mBluetoothGatt;  // 手机连接蓝牙设备，所需要的与之相关的GATT链接   （蓝牙属性协议）
    private BluetoothDevice mBluetoothDevice;  //从扫描设备的设备列表里选出目标设备。
    private List<BluetoothGattCharacteristic> mCharacteristicList = new ArrayList<>(); //服务的特征列表

    /**
     * 本机设备发起连接操作时首先调用 onConnectionStateChange
     * @param gatt
     * @param status
     * @param newState
     */
    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
        super.onConnectionStateChange(gatt, status, newState);
        //当设备与中心设备连接状态发生改变时。
        switch (newState){
            case 2:
                // TODO: 2018/2/6  连接成功操作
                onStateConnected(gatt);
                break;
            case 0:
                // TODO: 2018/2/6  连接失败操作
                onstateDisconnected(gatt);
                break;
        }

    }

    /**
     *  蓝牙断开连接关闭gatt
     * @param gatt
     */
    private void onstateDisconnected(BluetoothGatt gatt) {
        gatt.close();
    }

    /**
     * 蓝牙连接
     * @param gatt
     */
    private void onStateConnected(BluetoothGatt gatt) {
        gatt.discoverServices();
    }

    @Override
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
        super.onServicesDiscovered(gatt, status);
        //当发现设备服务时，回调
        if (status == BluetoothGatt.GATT_SUCCESS) {
            //gatt.getServices()可以获得外设的所有服务。
            for (BluetoothGattService service : gatt.getServices()) {//接下来遍历所有服务
                //每发现一个服务，我们再次遍历服务当中所包含的特征，service.getCharacteristics()可以获得当前服务所包含的所有特征
                for (BluetoothGattCharacteristic characteristic : service.getCharacteristics()) {
//                    mCharacteristics.add(characteristic);//通常可以把所发现的特征放进一个列表当中以便后续操作。
                    Logger.d(characteristic.getUuid().toString());
                    mCharacteristicList.add(characteristic);
                }
            }
        }
        gatt.readCharacteristic(mCharacteristicList.get(1)); // 读取第一个特征
    }

    @Override
    public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
        super.onDescriptorRead(gatt, descriptor, status);
        Log.i(TAG, "onDescriptorRead: ");
    }

    @Override
    public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
        super.onDescriptorWrite(gatt, descriptor, status);
        Log.i(TAG, "onDescriptorWrite: ");
    }

    @Override
    public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
        super.onReliableWriteCompleted(gatt, status);
        Log.i(TAG, "onReliableWriteCompleted: ");
    }

    @Override
    public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
        super.onReadRemoteRssi(gatt, rssi, status);
        Log.i(TAG, "onReadRemoteRssi: ");
    }

    @Override
    public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        super.onCharacteristicRead(gatt, characteristic, status);
        //特征读取回调
        if (status == BluetoothGatt.GATT_SUCCESS){
            //如果程序执行到这里，证明特征的读取已经完成，我们可以在回调当中取出特征的值。
            //特征所包含的值包含在一个byte数组内，我们可以定义一个临时变量来获取。

            byte[] characteristicValueBytes = characteristic.getValue();
            //如果这个特征返回的是一串字符串，那么可以直接获得其值
            String bytesToString = new String(characteristicValueBytes );

            //如果只需要取得其中的几个byte，可以直接指定获取特定的数组位置的byte值.
            //例如协议当中定义了这串数据当中前2个byte表示特定一个数值，那么获取这个值，可以直接写成
            byte[] aValueBytes = new byte[]{
                    characteristic.getValue()[0], characteristic.getValue()[1]
            };
            //至于这个值时表示什么，十进制数值？或是一个字符串？还是翻开协议慢慢找吧。
            //到这里为止，我们已经成功采用读的方式，获得了存在于特征当中的值。
            //characteristic还能为我们提供什么东西呢？属性，权限等是比较常用的。

        }
        Log.i(TAG, "onCharacteristicRead: ");
        Logger.d("onCharacteristicRead: ");
    }

    @Override
    public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        super.onCharacteristicWrite(gatt, characteristic, status);
        Log.i(TAG, "onCharacteristicWrite: ");
    }

    @Override
    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
        super.onCharacteristicChanged(gatt, characteristic);
        Log.i(TAG, "onCharacteristicChanged: ");
    }

    @Override
    public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
        super.onMtuChanged(gatt, mtu, status);
        Log.i(TAG, "onMtuChanged: ");
    }

}
